package estore.service;

import estore.model.Product5;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.io.*;
import java.util.Properties;

/**
 * 商品服务类，负责商品相关的业务逻辑
 * 目前使用内存Map模拟数据库
 */
public class ProductService5 {

    // 使用Map存储商品数据，key是商品ID，value是商品对象
    // 优点：通过ID查找商品时，时间复杂度是O(1)，非常高效
    private final Map<String, Product5> productData = new HashMap<>();
    private String dataFilePath = "products.dat";

    /**
     * 构造函数，初始化一些商品数据
     */
    public ProductService5() {
        loadConfig();
        loadData();
    }

    /**
     * 初始化示例数据
     */
    private void initializeSampleData() {
        productData.put("p001", new Product5("p001", "Java从入门到精通", 99.0, 100));
        productData.put("p002", new Product5("p002", "高性能MySQL", 128.5, 50));
        productData.put("p003", new Product5("p003", "颈椎康复指南", 45.0, 200));
        productData.put("p004", new Product5("p004", "生发秘籍", 88.0, 0)); // 库存为0的商品
        productData.put("p005", new Product5("p005", "Spring Boot实战", 79.0, 30));
        productData.put("p006", new Product5("p006", "Redis深度历险", 65.0, 80));
    }

    /**
     * 加载配置文件
     */
    private void loadConfig() {
        Properties props = new Properties();
        File configFile = new File("config.properties");

        if (!configFile.exists()) {
            return; // 使用默认路径
        }

        try (FileInputStream fis = new FileInputStream(configFile);
             InputStreamReader isr = new InputStreamReader(fis, "UTF-8")) {

            props.load(isr);
            String filePath = props.getProperty("data.file.path");
            if (filePath != null && !filePath.trim().isEmpty()) {
                dataFilePath = filePath;
            }
        } catch (IOException e) {
            System.out.println("读取配置文件失败: " + e.getMessage());
        }
    }

    /**
     * 从文件加载商品数据
     */
    @SuppressWarnings("unchecked")
    public void loadData() {
        File dataFile = new File(dataFilePath);
        if (!dataFile.exists()) {
            initializeSampleData(); // 文件不存在时初始化示例数据
            return;
        }

        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(dataFile))) {
            Map<String, Product5> loadedData = (Map<String, Product5>) ois.readObject();
            productData.clear();
            productData.putAll(loadedData);
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("加载数据文件失败: " + e.getMessage());
            initializeSampleData();
        }
    }

    /**
     * 保存商品数据到文件
     */
    public void saveData() {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(dataFilePath))) {
            oos.writeObject(productData);
        } catch (IOException e) {
            System.out.println("保存数据到文件失败: " + e.getMessage());
        }
    }

    /**
     * 备份数据文件
     */
    public void backupData() {
        File sourceFile = new File(dataFilePath);
        if (!sourceFile.exists()) {
            System.out.println("源数据文件不存在，无法备份");
            return;
        }

        String backupFilePath = dataFilePath + ".bak";
        try (FileInputStream fis = new FileInputStream(sourceFile);
             FileOutputStream fos = new FileOutputStream(backupFilePath)) {

            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
            System.out.println("数据文件备份成功: " + backupFilePath);
        } catch (IOException e) {
            System.out.println("数据文件备份失败: " + e.getMessage());
        }
    }

    /**
     * 获取所有商品列表
     * @return 商品列表
     */
    public List<Product5> getAllProducts() {
        // 从Map的值集合创建一个新的ArrayList并返回
        return new ArrayList<>(productData.values());
    }

    /**
     * 根据ID查找商品
     * @param id 商品ID
     * @return 找到的商品对象，如果不存在则返回null
     */
    public Product5 findProductById(String id) {
        return productData.get(id);
    }

    /**
     * 添加新商品
     * @param product 商品对象
     * @return 添加成功返回true，如果ID已存在返回false
     */
    public boolean addProduct(Product5 product) {
        if (product == null || product.getId() == null || product.getId().trim().isEmpty()) {
            return false;
        }

        String id = product.getId().toLowerCase();
        if (productData.containsKey(id)) {
            return false; // ID已存在
        }

        productData.put(id, product);
        return true;
    }

    /**
     * 更新商品信息
     * @param product 商品对象
     * @return 更新成功返回true，如果商品不存在返回false
     */
    public boolean updateProduct(Product5 product) {
        if (product == null || product.getId() == null) {
            return false;
        }

        String id = product.getId().toLowerCase();
        if (!productData.containsKey(id)) {
            return false; // 商品不存在
        }

        productData.put(id, product);
        return true;
    }

    /**
     * 删除商品
     * @param id 商品ID
     * @return 删除成功返回true，如果商品不存在返回false
     */
    public boolean deleteProduct(String id) {
        if (id == null) {
            return false;
        }
        return productData.remove(id.toLowerCase()) != null;
    }

    /**
     * 根据名称搜索商品（模糊搜索）
     * @param name 商品名称关键词
     * @return 匹配的商品列表
     */
    public List<Product5> searchProductsByName(String name) {
        if (name == null || name.trim().isEmpty()) {
            return new ArrayList<>();
        }

        String keyword = name.toLowerCase();
        return productData.values().stream()
                .filter(product -> product.getName().toLowerCase().contains(keyword))
                .collect(Collectors.toList());
    }

    /**
     * 获取有库存的商品列表
     * @return 有库存的商品列表
     */
    public List<Product5> getAvailableProducts() {
        return productData.values().stream()
                .filter(Product5::isInStock)
                .collect(Collectors.toList());
    }

    /**
     * 获取缺货的商品列表
     * @return 库存为0的商品列表
     */
    public List<Product5> getOutOfStockProducts() {
        return productData.values().stream()
                .filter(product -> !product.isInStock())
                .collect(Collectors.toList());
    }

    /**
     * 根据价格范围筛选商品
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @return 价格范围内的商品列表
     */
    public List<Product5> getProductsByPriceRange(double minPrice, double maxPrice) {
        if (minPrice < 0 || maxPrice < 0 || minPrice > maxPrice) {
            return new ArrayList<>();
        }

        return productData.values().stream()
                .filter(product -> product.getPrice() >= minPrice && product.getPrice() <= maxPrice)
                .collect(Collectors.toList());
    }

    /**
     * 减少商品库存
     * @param productId 商品ID
     * @param quantity 减少的数量
     * @return 操作成功返回true，库存不足或商品不存在返回false
     */
    public boolean decreaseStock(String productId, int quantity) {
        Product5 product = findProductById(productId);
        if (product == null) {
            return false;
        }

        return product.decreaseStock(quantity);
    }

    /**
     * 增加商品库存
     * @param productId 商品ID
     * @param quantity 增加的数量
     * @return 操作成功返回true，商品不存在返回false
     */
    public boolean increaseStock(String productId, int quantity) {
        Product5 product = findProductById(productId);
        if (product == null) {
            return false;
        }

        product.increaseStock(quantity);
        return true;
    }

    /**
     * 检查商品库存是否足够
     * @param productId 商品ID
     * @param quantity 需要的数量
     * @return 库存足够返回true，否则返回false
     */
    public boolean checkStock(String productId, int quantity) {
        Product5 product = findProductById(productId);
        return product != null && product.hasSufficientStock(quantity);
    }

    /**
     * 获取商品总数
     * @return 商品总数
     */
    public int getTotalProductCount() {
        return productData.size();
    }

    /**
     * 获取所有商品的库存总量
     * @return 库存总量
     */
    public int getTotalStockQuantity() {
        return productData.values().stream()
                .mapToInt(Product5::getStock)
                .sum();
    }

    /**
     * 清空所有商品数据（用于测试或重置）
     */
    public void clearAllProducts() {
        productData.clear();
    }

    /**
     * 重新初始化示例数据
     */
    public void resetToSampleData() {
        clearAllProducts();
        initializeSampleData();
    }

    /**
     * 批量添加商品
     * @param products 商品列表
     * @return 成功添加的商品数量
     */
    public int addProducts(List<Product5> products) {
        if (products == null || products.isEmpty()) {
            return 0;
        }

        int count = 0;
        for (Product5 product : products) {
            if (addProduct(product)) {
                count++;
            }
        }
        return count;
    }

    /**
     * 获取商品ID列表
     * @return 所有商品ID列表
     */
    public List<String> getAllProductIds() {
        return new ArrayList<>(productData.keySet());
    }
}